home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 7 / BBS in a Box - Macintosh - Volume VII (BBS in a Box) (January 1993).iso / Files / Prog / Q-R / QDPat.cpt / DrawMondrian < prev    next >
Encoding:
Text File  |  1989-10-23  |  4.4 KB  |  315 lines  |  [TEXT/PJMM]
  1. unit DrawMondrian;
  2.  
  3. interface
  4.  
  5.     uses
  6.         Utilities, Globals;
  7.  
  8.     procedure GenerateRectangles;
  9.     procedure GenerateSquares;
  10.     procedure GenerateCircles;
  11.     procedure GenerateTriangles;
  12.  
  13. implementation
  14.  
  15.  
  16.  
  17.     procedure GenerateRectangles;
  18.         const
  19.             OPRANGE = 10;
  20.             DELAY = 20;
  21.  
  22.         var
  23.             windowWidth: integer;
  24.             windowHeigth: integer;
  25.             corner1: point;
  26.             corner2: point;
  27.             randomRect: rect;
  28.             operation: integer;
  29.             HowWide, HowHigh: integer;
  30.  
  31.     begin
  32.  
  33.         with ScreenBits.bounds do
  34.             begin
  35.                 HowWide := right - left;
  36.                 HowHigh := bottom - top
  37.             end;
  38.  
  39.         with corner1 do
  40.             begin
  41.                 h := Randomize(HowWide);
  42.                 v := Randomize(HowHigh);
  43.             end;
  44.         with corner2 do
  45.             begin
  46.                 h := Randomize(HowWide);
  47.                 v := Randomize(HowHigh);
  48.             end;
  49.         SystemTask;
  50.         Pt2Rect(corner1, corner2, randomRect);
  51.         SystemTask;
  52.         operation := Randomize(OPRANGE);
  53.         case operation of
  54.             0: 
  55.                 PaintRect(randomRect);
  56.             1: 
  57.                 EraseRect(randomRect);
  58.             otherwise
  59.                 InvertRect(randomRect)
  60.         end;
  61.         Wait(2);
  62.         SystemTask;
  63.         Wait(2);
  64.         SystemTask;
  65.         Wait(2);
  66.         SystemTask;
  67.         Wait(2);
  68.         SystemTask;
  69.         Wait(2);
  70.         SystemTask;
  71.         Wait(2);
  72.         SystemTask;
  73.         Wait(2);
  74.         SystemTask;
  75.         Wait(2);
  76.         SystemTask;
  77.         Wait(2);
  78.         SystemTask;
  79.         Wait(2);
  80.         SystemTask;
  81.  
  82.  
  83.  
  84.  
  85.  
  86.  
  87.  
  88.  
  89.     end;
  90.     procedure GenerateSquares;
  91.         const
  92.             OPRANGE = 10;
  93.             DELAY = 20;
  94.  
  95.         var
  96.             windowWidth: integer;
  97.             windowHeigth: integer;
  98.             corner1: point;
  99.             corner2: point;
  100.             randomRect: rect;
  101.             operation: integer;
  102.             HowWide, HowHigh, r: integer;
  103.  
  104.     begin
  105.  
  106.         with ScreenBits.bounds do
  107.             begin
  108.                 HowWide := right - left;
  109.                 HowHigh := bottom - top
  110.             end;
  111.  
  112.         with corner1 do
  113.             begin
  114.                 h := Randomize(HowWide);
  115.                 v := Randomize(HowHigh);
  116.             end;
  117.         with corner2 do
  118.             begin
  119.                 r := Randomize(180);
  120.                 h := corner1.h + r;
  121.                 v := corner1.v + r;
  122.             end;
  123.         SystemTask;
  124.         Pt2Rect(corner1, corner2, randomRect);
  125.         SystemTask;
  126.         operation := Randomize(OPRANGE);
  127.         case operation of
  128.             0: 
  129.                 PaintRect(randomRect);
  130.             1: 
  131.                 EraseRect(randomRect);
  132.             otherwise
  133.                 InvertRect(randomRect)
  134.         end;
  135.         Wait(2);
  136.         SystemTask;
  137.         Wait(2);
  138.         SystemTask;
  139.         Wait(2);
  140.         SystemTask;
  141.         Wait(2);
  142.         SystemTask;
  143.         Wait(2);
  144.         SystemTask;
  145.         Wait(2);
  146.         SystemTask;
  147.         Wait(2);
  148.         SystemTask;
  149.         Wait(2);
  150.         SystemTask;
  151.         Wait(2);
  152.         SystemTask;
  153.         Wait(2);
  154.         SystemTask;
  155.  
  156.  
  157.  
  158.  
  159.  
  160.  
  161.  
  162.     end;
  163.     procedure GenerateCircles;
  164.         const
  165.             OPRANGE = 10;
  166.             DELAY = 20;
  167.  
  168.         var
  169.             windowWidth: integer;
  170.             windowHeigth: integer;
  171.             corner1: point;
  172.             corner2: point;
  173.             randomRect: rect;
  174.             operation: integer;
  175.             HowWide, HowHigh, r: integer;
  176.  
  177.     begin
  178.  
  179.         with ScreenBits.bounds do
  180.             begin
  181.                 HowWide := right - left;
  182.                 HowHigh := bottom - top
  183.             end;
  184.  
  185.         with corner1 do
  186.             begin
  187.                 h := Randomize(HowWide);
  188.                 v := Randomize(HowHigh);
  189.             end;
  190.         with corner2 do
  191.             begin
  192.                 r := Randomize(180);
  193.                 h := corner1.h + r;
  194.                 v := corner1.v + r;
  195.             end;
  196.         SystemTask;
  197.         Pt2Rect(corner1, corner2, randomRect);
  198.         SystemTask;
  199.         operation := Randomize(OPRANGE);
  200.         case operation of
  201.             0: 
  202.                 PaintOval(randomRect);
  203.             1: 
  204.                 EraseOval(randomRect);
  205.             otherwise
  206.                 InvertOval(randomRect)
  207.         end;
  208.         Wait(2);
  209.         SystemTask;
  210.         Wait(2);
  211.         SystemTask;
  212.         Wait(2);
  213.         SystemTask;
  214.         Wait(2);
  215.         SystemTask;
  216.         Wait(2);
  217.         SystemTask;
  218.         Wait(2);
  219.         SystemTask;
  220.         Wait(2);
  221.         SystemTask;
  222.         Wait(2);
  223.         SystemTask;
  224.         Wait(2);
  225.         SystemTask;
  226.         Wait(2);
  227.         SystemTask;
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.     end;
  236.     procedure GenerateTriangles;
  237.         const
  238.             OPRANGE = 10;
  239.             DELAY = 20;
  240.  
  241.         var
  242.             thePolygon: Polyhandle;
  243.             windowWidth: integer;
  244.             windowHeigth: integer;
  245.             corner1: point;
  246.             corner2, corner3: point;
  247.             operation: integer;
  248.             HowWide, HowHigh, r: integer;
  249.  
  250.     begin
  251.         with ScreenBits.bounds do
  252.             begin
  253.                 HowWide := right - left;
  254.                 HowHigh := bottom - top
  255.             end;
  256.         with corner1 do
  257.             begin
  258.                 h := Randomize(HowWide);
  259.                 v := Randomize(HowHigh);
  260.             end;
  261.         SystemTask;
  262.         HowHigh := Randomize(180);
  263.         r := Integer(HowHigh);
  264.         HowWide := r div 2;
  265.         thePolygon := OpenPoly;
  266.         MoveTo(corner1.h, corner1.v);
  267.         Line(HowHigh, HowWide);
  268.         Line(0, -(HowWide * 2));
  269.         Line(-(HowHigh), HowWide);
  270.         ClosePoly;
  271.         SystemTask;
  272.  
  273.  
  274.         operation := Randomize(OPRANGE);
  275.         case operation of
  276.             0: 
  277.                 PaintPoly(thePolygon);
  278.             1: 
  279.                 ErasePoly(thePolygon);
  280.             otherwise
  281.                 InvertPoly(thePolygon)
  282.         end;
  283.         KillPoly(thePolygon);
  284.         Wait(2);
  285.         SystemTask;
  286.         Wait(2);
  287.         SystemTask;
  288.         Wait(2);
  289.         SystemTask;
  290.         Wait(2);
  291.         SystemTask;
  292.         Wait(2);
  293.         SystemTask;
  294.         Wait(2);
  295.         SystemTask;
  296.         Wait(2);
  297.         SystemTask;
  298.         Wait(2);
  299.         SystemTask;
  300.         Wait(2);
  301.         SystemTask;
  302.         Wait(2);
  303.         SystemTask;
  304.  
  305.  
  306.  
  307.  
  308.  
  309.  
  310.  
  311.     end;
  312.  
  313.  
  314.  
  315. end.